பாண்டிட் பாதுகாப்பு லின்டிங்: பைதான் பாதுகாப்பு பாதிப்புகளை அடையாளம் கண்டு தணித்தல்

இன்றைய சிக்கலான இணைய பாதுகாப்புச் சூழலில், செயலூக்கமான பாதுகாப்பு நடவடிக்கைகள் மிக முக்கியமானவை. அதன் பன்முகத்தன்மை மற்றும் எளிதாகப் பயன்படுத்தக்கூடிய தன்மைக்காக அறியப்பட்ட பைதான், பல்வேறு பயன்பாடுகளுக்கு ஒரு பிரபலமான தேர்வாகும். இருப்பினும், எந்தவொரு நிரலாக்க மொழியையும் போலவே, பைதான் குறியீடும் பாதுகாப்பு பாதிப்புகளுக்கு ஆளாகக்கூடும். இங்கிருந்துதான் பாண்டிட் வருகிறது – உங்கள் பைதான் குறியீட்டில் உள்ள சாத்தியமான பாதுகாப்பு குறைபாடுகளை தானாகவே கண்டறிய வடிவமைக்கப்பட்ட ஒரு சக்திவாய்ந்த பாதுகாப்பு லின்டிங் கருவி.

பாண்டிட் என்றால் என்ன?

பாண்டிட் என்பது பைதானுக்காக சிறப்பாக வடிவமைக்கப்பட்ட ஒரு திறந்த மூல பாதுகாப்பு லின்டர் ஆகும். இது பொதுவான பாதுகாப்புச் சிக்கல்களுக்காக பைதான் குறியீட்டை ஸ்கேன் செய்வதன் மூலம் செயல்படுகிறது, சாத்தியமான பாதிப்புகளைக் கண்டறிய விரிவான செருகுநிரல் தொகுப்பைப் பயன்படுத்துகிறது. இது ஒரு நிலையான பகுப்பாய்வுக் கருவியாகக் கருதுங்கள், இது மேம்பாட்டு சுழற்சியின் ஆரம்பத்திலேயே பாதுகாப்புச் சிக்கல்களைக் கண்டறிய உதவுகிறது, அவை உற்பத்தியில் பயன்படுத்தப்படுவதற்கு முன்பு.

பாண்டிட் பைதான் குறியீட்டைப் பகுப்பாய்வு செய்து ஒரு சுருக்கமான தொடரியல் மரத்தை (AST) உருவாக்குவதன் மூலம் செயல்படுகிறது. பின்னர், அறியப்பட்ட பாதிப்பு முறைகளின் அடிப்படையில் பல சோதனைகளை AST-க்கு பயன்படுத்துகிறது. ஒரு சாத்தியமான பாதுகாப்புச் சிக்கல் கண்டறியப்படும்போது, பாண்டிட் அதை ஒரு தீவிர நிலை, நம்பிக்கையின் நிலை மற்றும் சிக்கலின் விரிவான விளக்கத்துடன் தெரிவிக்கிறது.

பாண்டிட் ஏன் பயன்படுத்த வேண்டும்?

உங்கள் மேம்பாட்டு பணிப்பாய்வில் பாண்டிட்டை ஒருங்கிணைப்பது பல குறிப்பிடத்தக்க நன்மைகளை வழங்குகிறது:

• ஆரம்ப பாதிப்பு கண்டறிதல்: மேம்பாட்டு செயல்முறையின் ஆரம்பத்திலேயே பாதுகாப்பு பாதிப்புகளைக் கண்டறிய பாண்டிட் உங்களுக்கு உதவுகிறது, இதனால் பின்னர் அவற்றை சரிசெய்ய தேவைப்படும் செலவையும் முயற்சியையும் குறைக்கிறது.
• மேம்படுத்தப்பட்ட குறியீட்டுத் தரம்: பாதுகாப்பான குறியீட்டு நடைமுறைகளை அமல்படுத்துவதன் மூலம், பாண்டிட் ஒட்டுமொத்த குறியீட்டுத் தரத்திற்கும் பராமரிப்பிற்கும் பங்களிக்கிறது.
• தானியங்கு பாதுகாப்பு தணிக்கைகள்: பாண்டிட் பாதுகாப்பு தணிக்கை செயல்முறையை தானியங்குபடுத்துகிறது, உங்கள் குறியீடு பாதுகாப்பு சிறந்த நடைமுறைகளுக்கு இணங்குவதை உறுதிசெய்வதை எளிதாக்குகிறது.
• OWASP முதல் 10 கவரேஜ்: OWASP முதல் 10 இல் பட்டியலிடப்பட்டுள்ள பல பாதிப்புகளை நிவர்த்தி செய்யும் சோதனைகளை பாண்டிட் உள்ளடக்கியது, பொதுவான வலைப்பயன்பாட்டு பாதுகாப்பு அபாயங்களிலிருந்து உங்களைப் பாதுகாக்க உதவுகிறது.
• தனிப்பயனாக்கக்கூடிய விதிகள்: உங்கள் குறிப்பிட்ட பாதுகாப்புத் தேவைகள் மற்றும் குறியீட்டுத் தரங்களுக்கு ஏற்ப பாண்டிட்டின் விதிகளை நீங்கள் தனிப்பயனாக்கலாம்.
• CI/CD பைப்லைன்களுடன் ஒருங்கிணைப்பு: பாண்டிட் உங்கள் தொடர்ச்சியான ஒருங்கிணைப்பு/தொடர்ச்சியான வரிசைப்படுத்தல் (CI/CD) பைப்லைன்களில் எளிதாக ஒருங்கிணைக்கப்படலாம், ஒவ்வொரு குறியீடு மாற்றத்திலும் பாதுகாப்புச் சோதனைகள் தானாகவே செய்யப்படுவதை உறுதிசெய்கிறது.

பாண்டிட் உடன் தொடங்குதல்

பாண்டிட் உடன் தொடங்குவதற்கான படிப்படியான வழிகாட்டி இங்கே:

1. நிறுவல்

பைதான் தொகுப்பு நிறுவி PIP ஐப் பயன்படுத்தி பாண்டிட்டை நிறுவலாம்:

            pip install bandit
            

              
                Copy
              
            
          

2. பாண்டிட்டை இயக்குதல்

உங்கள் பைதான் குறியீட்டில் பாண்டிட்டை இயக்க, பின்வரும் கட்டளையைப் பயன்படுத்தவும்:

            bandit -r <directory>
            

              
                Copy
              
            
          

<directory> என்பதை உங்கள் பைதான் குறியீடு உள்ள அடைவுடன் மாற்றவும். -r கொடி, குறிப்பிட்ட அடைவில் உள்ள அனைத்து பைதான் கோப்புகளையும் மீண்டும் மீண்டும் ஸ்கேன் செய்ய பாண்டிட்டிற்குத் தெரிவிக்கிறது.

தனிப்பட்ட கோப்புகளையும் குறிப்பிடலாம்:

            bandit <file1.py> <file2.py>
            

              
                Copy
              
            
          

3. முடிவுகளை விளக்குதல்

உங்கள் குறியீட்டில் கண்டறியப்பட்ட சாத்தியமான பாதுகாப்பு பாதிப்புகளை விவரிக்கும் ஒரு அறிக்கையை பாண்டிட் வெளியிடும். ஒவ்வொரு பாதிப்புக்கும் ஒரு தீவிர நிலை (எ.கா., HIGH, MEDIUM, LOW) மற்றும் ஒரு நம்பிக்கையின் நிலை (எ.கா., HIGH, MEDIUM, LOW) ஒதுக்கப்படும். அறிக்கையில் பாதிப்பின் விரிவான விளக்கம் மற்றும் அது கண்டறியப்பட்ட குறியீட்டு வரிசையும் அடங்கும்.

பாண்டிட் வெளியீட்டின் எடுத்துக்காட்டு:

            ./example.py:10:0:B603  [blacklist] Use of subprocess.Popen with shell=True is known to be vulnerable to shell injection
	Severity: High   Confidence: High
	Location: ./example.py:10
--------------------------------------------------

            

              
                Copy
              
            
          

இந்த வெளியீடு, example.py கோப்பில் 10வது வரியில் ஒரு உயர்-தீவிர பாதிப்பை பாண்டிட் கண்டறிந்துள்ளது என்பதைக் குறிக்கிறது. இந்தப் பாதிப்பு subprocess.Popen உடன் shell=True ஐப் பயன்படுத்துவதுடன் தொடர்புடையது, இது ஷெல் இன்ஜெக்ஷன் தாக்குதல்களுக்கு ஆளாகக்கூடியது என அறியப்படுகிறது.

பாண்டிட் கண்டறியும் பொதுவான பாதுகாப்பு பாதிப்புகள்

பைதான் குறியீட்டில் உள்ள பல பொதுவான பாதுகாப்பு பாதிப்புகளை பாண்டிட் கண்டறிய முடியும். சில எடுத்துக்காட்டுகள் இங்கே:

• ஷெல் இன்ஜெக்ஷன் (B602, B603): நம்பத்தகாத உள்ளீடுகளுடன் subprocess.Popen அல்லது os.system ஐப் பயன்படுத்துவது ஷெல் இன்ஜெக்ஷன் தாக்குதல்களுக்கு வழிவகுக்கும்.
• SQL இன்ஜெக்ஷன் (B608): பயனர் வழங்கிய தரவுகளுடன் சரம் இணைப்பைப் பயன்படுத்தி SQL வினவல்களை உருவாக்குவது உங்கள் பயன்பாட்டை SQL இன்ஜெக்ஷன் தாக்குதல்களுக்கு வெளிப்படுத்தலாம்.
• ஹார்ட்கோடட் கடவுச்சொற்கள் (B105): உங்கள் குறியீட்டில் கடவுச்சொற்களை நேரடியாகச் சேமிப்பது ஒரு பெரிய பாதுகாப்பு அபாயம்.
• பலவீனமான குறியாக்கம் (B303, B304, B322): பலவீனமான அல்லது காலாவதியான குறியாக்க வழிமுறைகளைப் பயன்படுத்துவது உங்கள் தரவின் இரகசியத்தன்மையையும் ஒருமைப்பாட்டையும் பாதிக்கலாம்.
• பாதுகாப்பற்ற வரிசைநீக்கம் (B301, B401): நம்பத்தகாத மூலங்களிலிருந்து தரவை வரிசைநீக்கம் செய்வது தன்னிச்சையான குறியீடு செயல்படுத்துதலுக்கு வழிவகுக்கும்.
• XML வெளிப்புற நிறுவனம் (XXE) இன்ஜெக்ஷன் (B405): நம்பத்தகாத மூலங்களிலிருந்து XML ஆவணங்களை சரியான சானிடைசேஷன் இல்லாமல் பகுப்பாய்வு செய்வது உங்கள் பயன்பாட்டை XXE இன்ஜெக்ஷன் தாக்குதல்களுக்கு வெளிப்படுத்தலாம்.
• வடிவமைப்பு சரம் பாதிப்புகள் (B323): வடிவமைப்பு சரங்களில் பயனர் வழங்கிய தரவை சரியான சானிடைசேஷன் இல்லாமல் பயன்படுத்துவது வடிவமைப்பு சரம் பாதிப்புகளுக்கு வழிவகுக்கும்.
• `eval()` அல்லது `exec()` ஐப் பயன்படுத்துதல் (B301): இந்தச் செயல்பாடுகள் தன்னிச்சையான குறியீட்டைச் செயல்படுத்துகின்றன, மேலும் நம்பத்தகாத உள்ளீடுகளுடன் அவற்றைப் பயன்படுத்துவது மிகவும் ஆபத்தானது.
• பாதுகாப்பற்ற தற்காலிக கோப்புப் பயன்பாடு (B308): கணிக்கக்கூடிய இடத்தில் தற்காலிக கோப்புகளை உருவாக்குவது தாக்குபவர்கள் உணர்திறன் தரவை மேலெழுதவோ அல்லது படிக்கவோ அனுமதிக்கலாம்.
• காணாமல் போன அல்லது தவறான பிழை கையாளுதல் (B110): விதிவிலக்குகளை சரியாகக் கையாளாதது உணர்திறன் தகவலை வெளிப்படுத்தலாம் அல்லது சேவை மறுப்புத் தாக்குதல்களுக்கு வழிவகுக்கும்.

எடுத்துக்காட்டு: ஒரு ஷெல் இன்ஜெக்ஷன் பாதிப்பை அடையாளம் கண்டு சரிசெய்தல்

ஷெல் இன்ஜெக்ஷன் பாதிப்பை பாண்டிட் எவ்வாறு அடையாளம் கண்டு சரிசெய்ய உதவும் என்பதற்கு ஒரு எளிய எடுத்துக்காட்டைக் காணலாம்.

பின்வரும் பைதான் குறியீட்டைக் கவனியுங்கள்:

            import subprocess
import os

def execute_command(command):
    subprocess.Popen(command, shell=True)

if __name__ == "__main__":
    user_input = input("Enter a command to execute: ")
    execute_command(user_input)

            

              
                Copy
              
            
          

இந்தக் குறியீடு பயனர் உள்ளீட்டை எடுத்து, subprocess.Popen உடன் shell=True ஐப் பயன்படுத்தி அதை ஒரு ஷெல் கட்டளையாக இயக்குகிறது. இது ஷெல் இன்ஜெக்ஷன் பாதிப்புக்கான ஒரு சிறந்த எடுத்துக்காட்டு.

இந்த குறியீட்டில் பாண்டிட்டை இயக்குவது பின்வரும் வெளியீட்டை உருவாக்கும்:

            ./example.py:4:0:B603  [blacklist] Use of subprocess.Popen with shell=True is known to be vulnerable to shell injection
	Severity: High   Confidence: High
	Location: ./example.py:4
--------------------------------------------------

            

              
                Copy
              
            
          

subprocess.Popen உடன் shell=True ஐப் பயன்படுத்துவதை உயர்-தீவிர பாதிப்பாக பாண்டிட் சரியாக அடையாளம் காட்டுகிறது.

இந்த பாதிப்பைச் சரிசெய்ய, நீங்கள் shell=True ஐப் பயன்படுத்துவதைத் தவிர்க்க வேண்டும், அதற்குப் பதிலாக கட்டளையையும் அதன் வாதங்களையும் ஒரு பட்டியலாக subprocess.Popen க்கு அனுப்ப வேண்டும். தீங்கிழைக்கும் கட்டளைகள் உட்செலுத்தப்படுவதைத் தடுக்க பயனர் உள்ளீட்டைச் சானிடைஸ் செய்யவும் வேண்டும்.

குறியீட்டின் திருத்தப்பட்ட பதிப்பு இங்கே:

            import subprocess
import shlex

def execute_command(command):
    # Sanitize the input using shlex.split to prevent shell injection
    command_list = shlex.split(command)
    subprocess.Popen(command_list)

if __name__ == "__main__":
    user_input = input("Enter a command to execute: ")
    execute_command(user_input)

            

              
                Copy
              
            
          

பயனர் உள்ளீட்டை சானிடைஸ் செய்ய shlex.split ஐப் பயன்படுத்துவதன் மூலமும், கட்டளையை ஒரு பட்டியலாக subprocess.Popen க்கு அனுப்புவதன் மூலமும், ஷெல் இன்ஜெக்ஷன் தாக்குதல்களின் அபாயத்தைக் குறைக்கலாம்.

திருத்தப்பட்ட குறியீட்டில் பாண்டிட்டை இயக்குவது ஷெல் இன்ஜெக்ஷன் பாதிப்பை இனி புகாரளிக்காது.

பாண்டிட்டை உள்ளமைத்தல்

பாண்டிட்டின் செயல்பாட்டைத் தனிப்பயனாக்க, ஒரு உள்ளமைவு கோப்பைப் (bandit.yaml அல்லது .bandit) பயன்படுத்தலாம். உள்ளமைவு கோப்பைப் பயன்படுத்தி நீங்கள் பின்வருவனவற்றைச் செய்யலாம்:

• கோப்புகள் அல்லது கோப்பகங்களைத் தவிர்த்தல்: ஸ்கேன் செய்யப்படாமல் தவிர்க்கப்பட வேண்டிய கோப்புகள் அல்லது கோப்பகங்களைக் குறிப்பிடவும்.
• குறிப்பிட்ட சோதனைகளை முடக்குதல்: உங்கள் திட்டத்திற்குத் தொடர்பில்லாத சோதனைகளை முடக்கவும்.
• தீவிர நிலைகளைச் சரிசெய்தல்: குறிப்பிட்ட பாதிப்புகளின் தீவிர நிலைகளை மாற்றவும்.
• தனிப்பயன் விதிகளை வரையறுத்தல்: திட்டத்திற்கேற்ப பாதுகாப்புச் சிக்கல்களைக் கண்டறிய உங்கள் சொந்த தனிப்பயன் விதிகளை உருவாக்கவும்.

ஒரு bandit.yaml உள்ளமைவு கோப்புக்கு ஒரு எடுத்துக்காட்டு இங்கே:

            exclude:
  - 'tests/'
  - 'docs/'

skips:
  - 'B101'

confidence_level:
  MEDIUM:
    - 'B603'

severity_level:
  LOW:
    - 'B105'

            

              
                Copy
              
            
          

இந்த உள்ளமைவு கோப்பு tests/ மற்றும் docs/ கோப்பகங்களை ஸ்கேன் செய்வதிலிருந்து விலக்குகிறது, B101 சோதனையைத் தவிர்க்கிறது (இது அசெர்ட் ஸ்டேட்மென்ட்களின் பயன்பாட்டைச் சரிபார்க்கிறது), B603 சோதனையின் நம்பிக்கையின் நிலையை MEDIUM ஆக சரிசெய்கிறது, மேலும் B105 சோதனையின் தீவிர நிலையை LOW ஆக சரிசெய்கிறது.

உங்கள் CI/CD பைப்லைனில் பாண்டிட்டை ஒருங்கிணைத்தல்

உங்கள் பைதான் குறியீட்டின் பாதுகாப்பை உறுதி செய்வதில், பாண்டிட்டை உங்கள் CI/CD பைப்லைனில் ஒருங்கிணைப்பது ஒரு முக்கிய படியாகும். ஒவ்வொரு குறியீடு மாற்றத்திலும் பாண்டிட்டை தானாக இயக்குவதன் மூலம், பாதுகாப்பு பாதிப்புகளை ஆரம்பத்திலேயே கண்டறிந்து அவை உற்பத்தியை அடைவதைத் தடுக்கலாம்.

ஒரு GitLab CI/CD பைப்லைனில் பாண்டிட்டை எவ்வாறு ஒருங்கிணைப்பது என்பதற்கான எடுத்துக்காட்டு இங்கே:

            stages:
  - test

bandit:
  image: python:3.9
  stage: test
  before_script:
    - pip install bandit
  script:
    - bandit -r .
  artifacts:
    reports:
      bandit: bandit.report

            

              
                Copy
              
            
          

இந்த உள்ளமைவு, நடப்பு கோப்பகத்தில் பாண்டிட்டை இயக்கும் ஒரு bandit வேலையை வரையறுக்கிறது. இந்த வேலை ஒரு பைதான் 3.9 டாக்கர் படத்தைப் பயன்படுத்துகிறது மற்றும் pip ஐப் பயன்படுத்தி பாண்டிட்டை நிறுவுகிறது. bandit -r . கட்டளை நடப்பு கோப்பகத்தில் உள்ள அனைத்து பைதான் கோப்புகளிலும் பாண்டிட்டை மீண்டும் மீண்டும் இயக்குகிறது. artifacts பிரிவு, பாண்டிட் அறிக்கை ஒரு ஆர்ட்டிஃபாக்டாக சேமிக்கப்பட வேண்டும் என்று குறிப்பிடுகிறது, அதை பதிவிறக்கம் செய்து மதிப்பாய்வு செய்யலாம்.

ஜென்கின்ஸ், சர்க்கிள்சிஐ மற்றும் கிட்ஹப் ஆக்ஷன்ஸ் போன்ற பிற CI/CD தளங்களுக்கும் இதே போன்ற உள்ளமைவுகளை உருவாக்கலாம்.

பாண்டிட்டிற்கு அப்பால்: விரிவான பாதுகாப்பு உத்திகள்

பாண்டிட் சாத்தியமான பாதுகாப்பு பாதிப்புகளைக் கண்டறிய ஒரு மதிப்புமிக்க கருவியாக இருந்தாலும், இது ஒரு விரிவான பாதுகாப்பு மூலோபாயத்தின் ஒரு பகுதி என்பதை நினைவில் கொள்வது முக்கியம். மற்ற முக்கியமான பாதுகாப்பு நடைமுறைகள்:

• பாதுகாப்பான குறியீட்டு நடைமுறைகள்: உங்கள் குறியீட்டில் பாதிப்புகளை அறிமுகப்படுத்தும் அபாயத்தைக் குறைக்க, பாதுகாப்பான குறியீட்டு வழிகாட்டுதல்கள் மற்றும் சிறந்த நடைமுறைகளைப் பின்பற்றவும்.
• வழக்கமான பாதுகாப்பு தணிக்கைகள்: உங்கள் பயன்பாட்டில் உள்ள சாத்தியமான பாதுகாப்பு பலவீனங்களை அடையாளம் கண்டு நிவர்த்தி செய்ய வழக்கமான பாதுகாப்பு தணிக்கைகளை நடத்தவும்.
• ஊடுருவல் சோதனை: நிஜ உலகத் தாக்குதல்களை உருவகப்படுத்தவும், பாண்டிட் போன்ற நிலையான பகுப்பாய்வுக் கருவிகளால் கண்டறிய முடியாத பாதிப்புகளை அடையாளம் காணவும் ஊடுருவல் சோதனையைச் செய்யவும்.
• பாதிப்பு மேலாண்மை: உங்கள் மென்பொருள் மற்றும் உள்கட்டமைப்பில் உள்ள பாதிப்புகளைக் கண்காணிக்கவும் சரிசெய்யவும் ஒரு பாதிப்பு மேலாண்மை திட்டத்தை செயல்படுத்தவும்.
• சார்பு மேலாண்மை: மூன்றாம் தரப்பு நூலகங்களில் அறியப்பட்ட பாதிப்புகளை சரிசெய்ய உங்கள் சார்புகளை புதுப்பித்த நிலையில் வைத்திருக்கவும். pip-audit மற்றும் safety போன்ற கருவிகள் இதற்கு உதவும்.
• உள்ளீட்டு சரிபார்ப்பு மற்றும் சானிடைசேஷன்: இன்ஜெக்ஷன் தாக்குதல்கள் மற்றும் பிற உள்ளீடு தொடர்பான பாதிப்புகளைத் தடுக்க எப்போதும் பயனர் உள்ளீட்டை சரிபார்த்து சானிடைஸ் செய்யவும்.
• அங்கீகாரம் மற்றும் அங்கீகார உரிமை: உணர்திறன் தரவு மற்றும் வளங்களைப் பாதுகாக்க வலுவான அங்கீகாரம் மற்றும் அங்கீகார உரிமை வழிமுறைகளைச் செயல்படுத்தவும்.
• பாதுகாப்பு விழிப்புணர்வு பயிற்சி: உங்கள் டெவலப்பர்கள் மற்றும் பிற ஊழியர்களுக்கு பொதுவான பாதுகாப்பு அச்சுறுத்தல்கள் மற்றும் சிறந்த நடைமுறைகள் பற்றி கல்வி கற்பிக்க பாதுகாப்பு விழிப்புணர்வு பயிற்சியை வழங்கவும்.

முடிவுரை

பைதான் குறியீட்டில் உள்ள பாதுகாப்பு பாதிப்புகளை அடையாளம் கண்டு தணிப்பதற்கு பாண்டிட் ஒரு மதிப்புமிக்க கருவியாகும். உங்கள் மேம்பாட்டு பணிப்பாய்வில் பாண்டிட்டை ஒருங்கிணைப்பதன் மூலம், உங்கள் பயன்பாடுகளின் பாதுகாப்பை மேம்படுத்தலாம் மற்றும் பொதுவான பாதுகாப்பு அச்சுறுத்தல்களிலிருந்து பாதுகாக்கலாம். இருப்பினும், பாண்டிட் ஒரு விரிவான பாதுகாப்பு மூலோபாயத்தின் ஒரு பகுதி என்பதை நினைவில் கொள்வது முக்கியம். பாதுகாப்பான குறியீட்டு நடைமுறைகளைப் பின்பற்றுவதன் மூலமும், வழக்கமான பாதுகாப்பு தணிக்கைகளை நடத்துவதன் மூலமும், பிற பாதுகாப்பு நடவடிக்கைகளை செயல்படுத்துவதன் மூலமும், நீங்கள் மிகவும் பாதுகாப்பான மற்றும் மீள்தன்மை கொண்ட மென்பொருள் சூழலை உருவாக்க முடியும்.

வளங்கள்

• பாண்டிட் ஆவணம்
• OWASP (ஓப்பன் வெப் அப்ளிகேஷன் செக்யூரிட்டி பிராஜெக்ட்)
• PyPI இல் பாண்டிட்